public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        System.out.println(a==1 || b==2);
       // System.out.println("\\\"hello\\\"");
    }
    public static void main223(String[] args) {
        int a=10;
        String str=a+" ";
        System.out.println(str);
        String arr=String.valueOf(a);
        System.out.println(arr);
       /* String a="123";
        int ret=Integer.parseInt(a);
        System.out.println(ret+1);*/
      /*  int a=10;
        System.out.println("a="+a);*/
       /* String s1 = "hello";
        String s2 = " world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接*/
    }
    public static void main342(String[] args) {
        byte a = 10;
        byte b = 20;
        int c = a + b;
        System.out.println(c);
  /*      int a = 10;
        long b = 20;
        int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long*/
    }
    public static void main222(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败

        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败

        //a = d; // 报错，类型不兼容
        a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃

        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错

       /* byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失
*/

     /*   float f = 3.14F;
        double d = 5.12;
        d = f; // 编译器会将f转换为double，然后进行赋值
        f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全*/


       /* int a = 100;
        long b = 10L;
        b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
        a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全

        */

     /*   System.out.println(1024); // 整型默认情况下是int
        System.out.println(3.14); // 浮点型默认情况下是double*/
      /*  int a = 10;
        long b = 100L;
        b = a; // 可以通过编译
        a = b; // 编译失败*/
    }
    public static void maina(String[] args) {
        boolean b = true;
        System.out.println(b);
        b = false;
        System.out.println(b);
    }
    public static void main01(String[] args) {
        char c1 = 'A'; // 大写字母
        char c2 = '1'; // 数字字符
        System.out.println(c1);
        System.out.println(c2);
// 注意：java中的字符可以存放整形
        char c3 = '帅';
        System.out.println(c3);
    }
    public static void main000(String[] args) {
        float a=1.0f;

    }
    public static void main1234(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a*1.0 / b); // 输出 0.5 吗？
       /* double d = 3.14;
        System.out.println(d);*/
    }
    public static void main11111(String[] args) {
       /* System.out.print("gege");
        System.out.print("\n");
        System.out.print("gege");*/
      /*  short a =128;
        byte b =(byte) a;
        System.out.println(a);
        System.out.println(b);*/
        System.out.println();
    }

    public static void main123(String[] args) {
        byte b = 10;
        byte a = 127;
        int c =a +b ;


/*        System.out.println(b);
// byte型变量所能表示的范围：
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);*/
    }
    public static void main1111(String[] args) {
        short a = 10;
        System.out.println(a);
// short型变量所能表示的范围：
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);
    }
    public static void main111(String[] args) {
       /* int a = 10;
        long b = 10; // long定义的长整型变量
        long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
        long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分*/
        // long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }
    public static void main11(String[] args) {
        // int型变量所能表示的范围：
       /* System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);*/
        // 注意：在定义int性变量时，所赋值不能超过int的范围
        int d = 1234901234; // 编译时报错，初值超过了int的范围
    }
    public static void main33(String[] args) {
        // 方式一：在定义时给出初始值
        int a = 10;
        System.out.println(a);
// 方式二：在定义时没有给初始值，但使用前必须设置初值
        int b;
        b = 10;
        System.out.println(b);
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
        int c;
        c = 100;

        System.out.println(c);

    }
    public static void main2(String[] args) {
        int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
        double d = 3.14;
        char c = 'A';
        boolean b = true;
        System.out.println(a);
        System.out.println(d);
        System.out.println(c);
        System.out.println(b);
        a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
        System.out.println(a);
// 注意：在一行可以定义多个相同类型的变量
        int a1 = 10, a2 = 20, a3 = 30;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
    }
    public static void main1(String[] args) {
        System.out.println("hello world!");
        System.out.println(100);
        System.out.println(3.14);
        System.out.println('A');
        System.out.println(true);
        System.out.println(false);
    }
}
